// app.js
App({
  // ======================
  // 🚀 生命周期方法
  // ======================
  onLaunch() {
    this.initApp();          // 初始化应用基础配置
    this.handleDevMode();     // 开发模式特殊处理
    this.checkUpdate();      // 检查小程序更新
    this.autoLoginCheck();   // 自动登录检查
  },

  // ======================
  // 🔧 初始化方法
  // ======================
  initApp() {
    this.initLogger();       // 初始化日志系统
    this.initSystemInfo();   // 获取系统信息
    this.initTheme();        // 初始化主题
  },

  /**
   * 开发模式处理
   */
  handleDevMode() {
    if (this.devConfig.enabled) {
      console.log('🔧 开发模式已启用')
      
      // 设置模拟用户数据
      if (this.devConfig.mockUsers) {
        const userKeys = Object.keys(this.devConfig.mockUsers)
        if (userKeys.length > 0) {
          const firstUser = this.devConfig.mockUsers[userKeys[0]]
          this.globalData.userInfo = {
            nickname: firstUser.nickname,
            avatar: firstUser.avatar
          }
          this.globalData.isLoggedIn = true
          console.log('📝 模拟用户数据已加载:', this.globalData.userInfo)
        }
      }
      
      // 设置调试状态
      if (this.devConfig.debug) {
        this.globalData.isLoggedIn = this.devConfig.debug.isLoggedIn !== false
        if (this.devConfig.debug.hasCouple) {
          const userKeys = Object.keys(this.devConfig.mockUsers || {})
          if (userKeys.length > 1) {
            this.globalData.coupleInfo = {
              partnerName: this.devConfig.mockUsers[userKeys[1]].nickname,
              partnerAvatar: this.devConfig.mockUsers[userKeys[1]].avatar,
              bindDate: new Date().toISOString()
            }
          }
        }
      }
    }
  },

  /**
   * 全局数据监听
   * @param {Object} watchMap 监听配置 {key: callback}
   * @returns {Function} 取消监听函数
   */
  watchGlobalData(watchMap) {
    const watchers = []
    const originalData = {...this.globalData}
    
    Object.keys(watchMap).forEach(key => {
      if (key in this.globalData) {
        const privateKey = `_${key}`
        this.globalData[privateKey] = this.globalData[key]
        
        Object.defineProperty(this.globalData, key, {
          get: () => this.globalData[privateKey],
          set: (value) => {
            this.globalData[privateKey] = value
            watchMap[key](value)
          }
        })
        
        watchers.push(() => {
          delete this.globalData[privateKey]
          this.globalData[key] = originalData[key]
        })
      }
    })
    
    return () => watchers.forEach(fn => fn())
  },
  
  /**
   * 初始化应用
   */
  initApp() {
    // 初始化日志
    const logs = wx.getStorageSync('logs') || [];
    logs.unshift(Date.now());
    wx.setStorageSync('logs', logs);
    
    // 初始化系统信息
    const systemInfo = wx.getSystemInfoSync();
    this.globalData.systemInfo = systemInfo;
    
    // 计算安全区域
    this.globalData.safeArea = systemInfo.safeArea || {};
    this.globalData.statusBarHeight = systemInfo.statusBarHeight || 20;
    
    // 初始化主题
    this.initTheme();
  },
  
  /**
   * 开发模式初始化
   */
  initDevMode() {
    console.log('🚀 开发模式已启用');
    
    // 设置模拟登录状态
    this.globalData.isLoggedIn = true;
    this.globalData.userInfo = this.devConfig.mockData.userInfo;
    this.globalData.coupleInfo = this.devConfig.mockData.coupleInfo;
    this.globalData.token = this.devConfig.mockData.token;
    
    console.log('📝 模拟用户数据已加载:', this.globalData.userInfo);
  },

  /**
   * 初始化主题
   */
  initTheme() {
    // 获取用户设置的主题，默认为浅色主题
    const theme = wx.getStorageSync('theme') || 'light';
    this.globalData.theme = theme;
    
    // 设置导航栏颜色
    if (theme === 'dark') {
      wx.setNavigationBarColor({
        frontColor: '#ffffff',
        backgroundColor: '#333333'
      });
    }
  },
  
  /**
   * 检查小程序更新
   */
  checkUpdate() {
    if (wx.canIUse('getUpdateManager')) {
      const updateManager = wx.getUpdateManager();
      
      updateManager.onCheckForUpdate(res => {
        if (res.hasUpdate) {
          updateManager.onUpdateReady(() => {
            wx.showModal({
              title: '更新提示',
              content: '新版本已准备好，是否重启应用？',
              success: res => {
                if (res.confirm) {
                  updateManager.applyUpdate();
                }
              }
            });
          });
          
          updateManager.onUpdateFailed(() => {
            wx.showToast({
              title: '更新失败，请稍后再试',
              icon: 'none'
            });
          });
        }
      });
    }
  },
  
  /**
   * 检查登录状态
   */
  checkLoginStatus() {
    // 获取本地存储的用户信息和token
    const token = wx.getStorageSync('token');
    const userInfo = wx.getStorageSync('userInfo');
    const coupleInfo = wx.getStorageSync('coupleInfo');
    
    if (token && userInfo) {
      // 已登录，设置全局用户信息
      this.globalData.isLoggedIn = true;
      this.globalData.token = token;
      this.globalData.userInfo = userInfo;
      this.globalData.coupleInfo = coupleInfo || null;
      
      // 检查token是否有效
      this.validateToken();
      return true;
    } else {
      // 未登录
      this.globalData.isLoggedIn = false;
      return false;
    }
  },

  /**
   * 自动登录检查（增强版）
   */
  autoLoginCheck() {
    if (this.devConfig.enabled && this.devConfig.debug?.isLoggedIn) {
      // 开发模式且配置为自动登录
      console.log('🔐 开发模式自动登录已启用');
      return;
    }
    
    // 生产环境检查登录状态
    if (!this.checkLoginStatus()) {
      console.log('⚠️ 未检测到登录状态');
      return;
    }

    // 验证token有效性（生产环境）
    if (!this.devConfig.enabled) {
      this.validateToken().catch(err => {
        console.error('Token验证失败:', err);
        this.logout();
        wx.showToast({
          title: '登录已过期',
          icon: 'none'
        });
      });
    }
  },

  /**
   * 验证token有效性（带重试机制）
   */
  async validateToken() {
    if (!this.globalData.token) {
      throw new Error('无有效token');
    }

    const maxRetries = 3;
    const baseDelay = 1000; // 初始延迟1秒
    let retryCount = 0;

    const executeValidation = async () => {
      const timeout = 5000; // 5秒超时
      const timeoutPromise = new Promise((_, reject) => {
        setTimeout(() => reject(new Error('验证超时')), timeout);
      });

      const validationPromise = new Promise((resolve, reject) => {
        // 模拟网络请求延迟
        setTimeout(() => {
          if (this.globalData.token.startsWith('valid_')) {
            resolve(true);
          } else {
            reject(new Error('无效token'));
          }
        }, 500);
      });

      return Promise.race([validationPromise, timeoutPromise]);
    };

    while (retryCount < maxRetries) {
      try {
        return await executeValidation();
      } catch (err) {
        retryCount++;
        console.warn(`验证失败 (${retryCount}/${maxRetries}):`, err.message);
        
        if (retryCount >= maxRetries) {
          throw err;
        }

        // 指数退避延迟
        const delay = baseDelay * Math.pow(2, retryCount - 1);
        await new Promise(resolve => setTimeout(resolve, delay));
        
        // 显示重试提示
        if (retryCount === 1) {
          wx.showToast({
            title: '网络不稳定，正在重试...',
            icon: 'none',
            duration: delay
          });
        }
      }
    }
  },

  /**
   * 路由拦截
   */
  routeInterceptor() {
    // 开发模式：关闭所有拦截
    if (this.devConfig.enabled) return true;

    const pages = getCurrentPages();
    const currentPage = pages[pages.length - 1];
    const path = `/${currentPage.route}`;

    // 白名单页面（无需任何验证）
    const whiteList = [
      '/pages/login/index',
      '/pages/register/index'
    ];
    if (whiteList.includes(path)) return true;

    // 1. 检查登录状态
    if (!this.checkLoginStatus()) {
      wx.redirectTo({ url: '/pages/login/index' });
      return false;
    }

    // 特殊页面（仅需登录）
    const loginOnlyPages = [
      '/pages/index/index',    // 首页
      '/pages/couple/bind'    // 绑定页
    ];
    if (loginOnlyPages.includes(path)) return true;

    // 2. 检查情侣关系（其他所有页面）
    if (!this.globalData.coupleInfo) {
      wx.redirectTo({ url: '/pages/couple/bind' });
      return false;
    }

    return true;
  },
  
  /**
   * 验证token有效性
   */
  validateToken() {
    // 这里可以调用后端API验证token
    // 如果token无效，清除登录状态
    // 实际项目中应该实现这个功能
  },
  
  /**
   * 登录方法
   * @param {Object} userInfo 用户信息
   * @param {String} token 登录令牌
   */
  login(userInfo, token) {
    // 保存用户信息和token
    this.globalData.isLoggedIn = true;
    this.globalData.userInfo = userInfo;
    this.globalData.token = token;
    
    // 存储到本地
    wx.setStorageSync('userInfo', userInfo);
    wx.setStorageSync('token', token);
  },
  
  /**
   * 退出登录
   */
  logout() {
    // 清除登录状态
    this.globalData.isLoggedIn = false;
    this.globalData.userInfo = null;
    this.globalData.token = '';
    this.globalData.coupleInfo = null;
    
    // 清除本地存储
    wx.removeStorageSync('userInfo');
    wx.removeStorageSync('token');
    wx.removeStorageSync('coupleInfo');
    
    // 跳转到登录页
    wx.reLaunch({
      url: '/pages/login/login'
    });
  },
  
  /**
   * 保存情侣信息
   * @param {Object} coupleInfo 情侣信息
   */
  saveCouple(coupleInfo) {
    this.globalData.coupleInfo = coupleInfo;
    wx.setStorageSync('coupleInfo', coupleInfo);
  },
  
  /**
   * 开发模式配置
   * 
   * 🎯 功能说明：
   * 开发模式下，系统会自动使用模拟数据，跳过登录验证和路由拦截，
   * 方便开发者快速测试页面功能和布局，无需连接真实后端API。
   * 
   * ⚙️ 配置说明：
   * - enabled: 开发模式总开关，true启用/false禁用
   * - mockUsers: 开发模式下使用的模拟测试数据
   * 
   * 🔧 使用场景：
   * 1. 前端页面开发调试
   * 2. 路由跳转测试
   * 3. UI组件样式验证
   * 4. 功能逻辑测试（无需真实登录）
   * 
   * 📝 注意事项：
   * - 发布到生产环境前，请确保设置为 enabled: false
   * - 模拟数据仅用于开发测试，不会影响生产环境数据
   * - 开发模式下所有API请求都会被模拟数据替代
   */
  devConfig: {
    // 🔘 核心开关
    enabled: true,  // 开发模式总开关
    
    // 👥 测试用户数据
    mockUsers: {
      user1: { 
        username: "dev_user1",
        password: "123456",
        nickname: "测试用户A",
        avatar: "/assets/icons/default-avatar.png"
      },
      user2: {
        username: "dev_user2",
        password: "123456", 
        nickname: "测试用户B",
        avatar: "/assets/icons/default-avatar.png"
      }
    },
    
    // 🎛️ 状态开关
    debug: {
      isLoggedIn: true,   // 登录状态
      hasCouple: true,    // 绑定状态
      mockAPI: true       // 启用API模拟
    },
    
    // 🔑 固定绑定码
    coupleCode: "131452",  // 永久有效
    
    // ⏱️ 模拟API延迟时间(ms)
    mockDelay: {
      generateCode: 800,
      bindCouple: 1000,
      unbindCouple: 800
    }
  },

  /**
   * 全局数据
   */
  globalData: {
    // 用户信息
    isLoggedIn: false,
    userInfo: null,
    token: '',
    
    // 情侣信息
    coupleInfo: null,
    
    // 系统信息
    systemInfo: {},
    safeArea: {},
    statusBarHeight: 20,
    
    // 主题设置
    theme: 'light',
    
    // API基础路径
    apiBaseUrl: 'https://api.example.com'
  }
});